/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package application;

import ASAInstruction.ASAInstructBloc;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

/**
 * Classe static permettant de gérer une pile de fonctions
 * @author O.Riad
 * @author D.Romain
 * 
 */
public class FunctionStack {
    
    private static Map<String, ASAInstructBloc> stack = new HashMap<String, ASAInstructBloc>();
    private static Map<String, List<String>> functionParams = new HashMap<String, List<String>>();
    public static Stack<String> execCurrentFunction = new Stack<String>();
    private static String parseCurrentFunction;
    
    /**
     * Permet d'ajouter des fonctions disponibles
     * @param functionName
     * @param instruction
     * @param params 
     */
    public static void addFunction(String functionName, ASAInstructBloc instruction, List<String> params){
        stack.put(functionName, instruction);        
        functionParams.put(functionName, params);
    }
    
    /**
     * Retourne le bloc d'instructions correspondant à la fonction
     * @param functionName
     * @return Retourne le bloc d'instructions correspondant à la fonction
     */
    public static ASAInstructBloc getCode(String functionName){
        return stack.get(functionName);
    }
    
    /**
     * Test si la fonction existe
     * @param functionName
     * @return 
     */
    public static boolean exists(String functionName){
        return stack.containsKey(functionName);
    }
    
    /**
     * Retourne la map<String, ASAInstructBloc
     * @return 
     */
    public static Map<String, ASAInstructBloc> getMap(){
        return stack;
    }
    
    /**
     * Ajoute la fonction à la pile d'exécution pour la gestion des appels
     * @param current 
     */
    public static void setExecCurrentFunction(String current){
        execCurrentFunction.push(current);
    }
    
    /**
     * Ajoute la fonction pour le parsage
     * @param parseCurrent 
     */
    public static void setParseCurrentFunction(String parseCurrent){
        parseCurrentFunction = parseCurrent;
    }
    
    /**
     * Renvoie le nom de la fonction courante sans dépiler la pile 
     * d'exécution
     * @return 
     */
    public static String getExecCurrentFunction(){
        return execCurrentFunction.peek();
    }
    
    /**
     * Renvoie le nom de la fonction courante lors du parsage
     * @return 
     */
    public static String getParseCurrentFunction(){
        return parseCurrentFunction;
    }
    
    /**
     * Dépile la fonction courante de la pile d'exécution
     */
    public static void leaveFunction(){
        execCurrentFunction.pop();
    }
    
    /**
     * Récupère la liste des paramètres de la fonction
     * @param functionName
     * @return 
     */
    public static List<String> getFunctionParams(String functionName){
        return functionParams.get(functionName);
    }
    
    public static Map<String, List<String>> getFunctionParams(){
        return functionParams;
    }
    
    /**
     * Vide la FunctionStacl afin d'executer un autre programme
     */
    public static void destroy(){
        stack.clear();
        functionParams.clear();
        parseCurrentFunction = "";
    }

}
